package com.wuhainan.beelzebub.common;

import com.wuhainan.beelzebub.utils.PageInfo;
import com.wuhainan.beelzebub.utils.TableData;
import com.wuhainan.beelzebub.utils.TypeEquals;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import java.lang.reflect.Field;

/**
 * <br>Created by 吴海南 on 2018/1/8.
 * <br>星期一 at 1:18.
 */
public class BaseService<T> {

    /**
     * 封装pageable
     *
     * @param pageInfo 分页信息
     * @return pageable
     */
    protected Pageable pageable(PageInfo pageInfo) {
        return new PageRequest(pageInfo.getPage(), pageInfo.getSize());
    }

    /**
     * 封装pageable
     *
     * @param pageInfo 分页信息
     * @param sort     排序
     * @return pageable
     */
    protected Pageable pageable(PageInfo pageInfo, Sort sort) {
        return new PageRequest(pageInfo.getPage(), pageInfo.getSize(), sort);
    }

    /**
     * 封装tableData
     *
     * @param page 分页
     * @return tableData
     */
    protected TableData tableData(Page<T> page) {
        return new TableData(page.getTotalElements(), page.getContent());
    }

    /**
     * 添加排序字段
     *
     * @param pageInfo  分页信息
     * @param sortValue 排序方式
     * @param sortName  排序字段名
     * @return sort
     */
    protected Sort sort(PageInfo pageInfo, Sort.Direction sortValue, String sortName) {
        Sort sort = new Sort(sortValue, sortName);//初始排序方式
        if (!"".equals(pageInfo.getSortName())) {
            //simple-table传来的排序方式 顺序ascend 倒序descend
            if ("ascend".equals(pageInfo.getSortValue())) {
                sort = new Sort(Sort.Direction.ASC, pageInfo.getSortName());
            } else if ("descend".equals(pageInfo.getSortValue())) {
                sort = new Sort(Sort.Direction.DESC, pageInfo.getSortName());
            }
        }
        return sort;
    }

    /**
     * 处理搜索字段
     *
     * @param entity 实体对象
     * @param cq     查询器
     * @param cb     查询构建
     * @param root   root
     */
    protected void search(T entity, CriteriaQuery cq, CriteriaBuilder cb, Root<T> root) {
        TypeEquals typeEquals = new TypeEquals();
        for (Field field : entity.getClass().getDeclaredFields()) {
            field.setAccessible(true);
            try {
                //如果是String类型的字段 按照模糊查询方式搜索
                if (typeEquals.isString(field)) {
                    if (!"".equals(field.get(entity)) && field.get(entity) != null) {
                        cq.where(cb.like(root.get(field.getName()), "%" + field.get(entity) + "%"));
                    }
                } else if (typeEquals.isBoolean(field)) {
                    if (field.get(entity) != null) {
                        cq.where(cb.equal(root.get(field.getName()), field.get(entity)));
                    }
                }else if (typeEquals.isInteger(field)) {
                    if (field.get(entity) != null) {
                        cq.where(cb.equal(root.get(field.getName()), field.get(entity)));
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
}
